// // // // #include <iostream>
// // // // #include <cstdio>
// // // // #include <stdlib.h>
// // // // #include <string>
// // // // #include <pthread.h>
// // // // #include <unistd.h>
// // // // #include <cstring>
// // // // // void* routine(void* args)
// // // // // {
// // // // //     std::string name(static_cast<const char*> (args));
// // // // //     while (true)
// // // // //     {
// // // // //         std::cout << "I em a new thread, my name is :" << name << std::endl;
// // // // //         sleep(1);
// // // // //     }
// // // // //     return 0;
// // // // // }
// // // // // int main()
// // // // // {
// // // // //     pthread_t tid;
// // // // //     auto n = pthread_create(&tid, nullptr,
// // // // //     routine, (void*)"thread-1");

// // // // //     if (n  != 0)
// // // // //     {
// // // // //         std::cout << "create thread error" << strerror(n) << std::endl;
// // // // //         return 1;
// // // // //     }

// // // // //     while (true)
// // // // //     {
// // // // //         std::cout << "I am the main thraed !!" << std::endl;
// // // // //         sleep(1);
// // // // //     }

// // // // //     return 0;
// // // // // }

// // // // // zdl: 现在我们试着直接使用 c++11的线程库
// // // // #include <thread>

// // // // int main()
// // // // {

// // // //     std::thread t([]()
// // // //                   {
// // // //         while (true)
// // // //         {
// // // //             std::cout << "I am the new thread, my name is:" << "thread -1 " << std::endl;
// // // //             sleep(1);
// // // //         } });
// // // //     while (true)
// // // //     {
// // // //         std::cout << "I am the main thread !!" << std::endl;
// // // //         sleep(1);
// // // //     }

// // // //     return 0;
// // // //     // return 0;

// // // //     return 0;
// // // // }

// // // // // zdl:: 现在我们就需要进行更进一步的学习

// // #include <cstdio>
// // #include <iostream>
// // #include <unistd.h>
// // #include <cstring>
// // #include <thread>
// // #include <string>

// // using std::cout, std::cin;

// // int gvalue = 100;
// // std::string toHex(pthread_t tid)
// // {
// //     // 4. 进程函数。线程共享
// //     char buffer[1024] = {};
// //     snprintf(buffer, sizeof(buffer), "0x%lx", tid);

// //     return buffer;
// // }

// // // zdl:: 现在这个我问题的答案也是十分的清晰了，现在我们就知道 void* 类型的地址可以 传递任意类型的
// // int main()
// // {

// //     // zdl:: 线程北川见出来就需要共享进程的时间片

// //     pthread_t tid1;
// //     pthread_create(&tid1, nullptr, [](void *args) -> void *
// //                    {

// //         std::string name  = static_cast<const char*>(args);
// //         while (true)
// //         {
// //             std::cout << "I am the new thraed, and my name is "<< name <<
// //             ", my tid is " << toHex(pthread_self())  << std::endl;
// //             sleep(1);
// //         }

// //         return nullptr; // 线程推出的标志1 就是直接返回
// //     }, (void *)"thraed-1");

// //     pthread_t tid2;
// //     pthread_create(&tid2, nullptr, [](void *args) ->void*
// //                    {

// //         std::string name  = static_cast<const char*>(args);
// //         while (true)
// //         {
// //             std::cout << "I am the new thraed, and my name is "<< name <<
// //             ", my tid is " << toHex(pthread_self())  << std::endl;
// //             sleep(1);
// //         }

// //         return nullptr; }, (void *)"thraed-2");

// //     pthread_t tid3;
// //     pthread_create(&tid3, nullptr, [](void *args) -> void *
// //                    {

// //         std::string name  = static_cast<const char*>(args);
// //         while (true)
// //         {
// //             std::cout << "I am the new thraed, and my name is "<< name <<
// //             ", my tid is " << toHex(pthread_self())  << std::endl;
// //             sleep(1);
// //         }

// //         return nullptr; }, (void *)"thraed-3");

// //     pthread_t tid4;
// //     pthread_create(&tid4, nullptr, [](void *args) -> void *
// //                    {

// //         std::string name  = static_cast<const char*>(args);
// //         while (true)
// //         {
// //             std::cout << "I am the new thread, and my name is "<< name <<
// //             ", my tid is " << toHex(pthread_self())  << std::endl;
// //             sleep(1);
// //         }

// //         return nullptr; }, (void *)"thraed-4");

// //     while (true)
// //     {
// //         std::cout << "我是main线程" << std::endl;

// //         sleep(1);
// //     }
// //     return 0;
// // }

// // // // detach 类似于分家

// // // #include<iostream>
// // // #include<cstdio>

// // // using std::cin, std::cout, std::endl;

// // // int main()
// // // {
// // //     cout << "现在我就想要做一件简单的事" << endl;
// // //     cout << "就简单的输入一个数字然后将他打印：" << endl;
// // //     int n; cin >> n;
// // //     cout << "ret = " << n << endl;
// // //     return 0;
// // // }

// #include<iostream>
// #include<cstdio>
// #include<cstring>
// #include<thread>
// #include<unistd.h>
// #include<string>
// #include<cstdlib>
// #include<memory>
// using std::endl, std::cin, std::cout;
// #define num 10
// // now ,let's talk about how threads exit;
// auto addr = std::make_shared<int>(0);

// void* start1(void*args)
// {

//     // pthread_detach(pthread_self());
//     std::string name(static_cast<const char*> (args));
//     int a = 100;
//     addr = std::make_shared<int>(a);
//     while (true)
//     {
//         cout << name << " local val a = " << a << std::endl;
//         sleep(1);
//         // pthread_exit((void*)10);
//     }
//     return 0;

// }
// int main()
// {

//     // 现在开始探讨 线程的退出问题
//     pthread_t tid[num];
//     pthread_create(&tid[1], nullptr,
//     start1, (void*)"thread-1");
//     pthread_detach(tid[1]);
//     void* ret = nullptr;
//     pthread_join(tid[1], &ret);
//     std::cout << "new thread exit code: " <<
//     reinterpret_cast<long>(ret) << std::endl;
//     //  现在我们想要拿到退出码

//     while (true)
//     {
//         cout << "此时主线程也在运行！！！" << std::endl;
//         sleep(1);
//     }

//     return 0;
// }

// // detach 现在相乘的分离就可以让整个线程的状态进行分离

#include <pthread.h>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <unistd.h>
using std::endl, std::cin, std::cout;
using std::string;
__thread int shared_value = 100;// zdl:: 现在我们就通过实验知道，这个就是现成的局部存储
std::string toHex(pthread_t tid)
{
    // zdl:: 这个函数的作用就是使用snptintf 转化格式化的数据
    char buffer[1024];
    snprintf(buffer, sizeof(buffer), "0x%lx", tid);
    return buffer; // 去掉最后的空格
}

void *start(void *args)
{

    std::string name(static_cast<const char *>(args));

    while (true)
    {
        // std::cout << "i am a new thread called : " << name
        //           << ", thread id is " << toHex(pthread_self())<< endl;

        std::cout << "I am a new thread, my name is: " << name
                <<  " and shared_value : " << shared_value <<
                " and the addr of shared_value is " << &shared_value << endl;
        
        sleep(1);
    }
    return nullptr;
}

int ma34in()
{

    pthread_t tid;
    pthread_create(&tid, nullptr, start,
                   (void *)"thread-1");
    while (true)
    {
        cout << "I am the main thread " << " and shared_value : " << shared_value <<
                " and the addr of shared_value is " << &shared_value << endl;
        shared_value += 10; // 修改共享变量
        sleep(1);
    }

    pthread_join(tid, nullptr);
    return 0;
}


#include<iostream>

using namespace std;

int main()
{

    ma34in();
    return 0;
}